home *** CD-ROM | disk | FTP | other *** search
/ Internet Publisher's Toolbox 2.0 / Internet Publisher's Toolbox.iso / internet / ntserver / wtsource / sockets.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-11-14  |  11.0 KB  |  422 lines
  1. /* WIDE AREA INFORMATION SERVER SOFTWARE        
  2.    No guarantees or restrictions.  See the readme file for the full standard 
  3.    disclaimer.  
  4.    5.29.90      Harry Morris, morris@think.com
  5. */
  6.  
  7. /* Copyright (c) CNIDR (see ../COPYRIGHT) */
  8.  
  9.  
  10. #ifndef lint
  11. static char *RCSid = "$Header: /archives/stelar/src/freeWAIS/freeWAIS-0.2/ir/RCS/sockets.c,v 1.2 93/07/01 19:14:22 warnock Exp $";
  12. #endif
  13. typedef struct sockaddr SOCKADDR;
  14. typedef struct sockaddr_in SOCKADDR_IN;
  15. /* Change log:
  16.  * $Log:        sockets.c,v $
  17.  * Revision 1.2  93/07/01  19:14:22  warnock
  18.  * Fix for gethostname from francois and jonathan
  19.  * 
  20.  * Revision 1.1  1993/02/16  15:05:35  freewais
  21.  * Initial revision
  22.  *
  23.  * Revision 1.23  92/05/06  17:34:41  jonathan
  24.  * Added Mach to some compiler switches.
  25.  * 
  26.  * Revision 1.22  92/04/28  15:21:14  jonathan
  27.  * Added decoding of IP address to DNS name in accept_client handler.
  28.  * 
  29.  * Revision 1.21  92/04/01  09:49:49  morris
  30.  * declared clr_socket static to stop gcc from complaining
  31.  * 
  32.  * Revision 1.20  92/03/24  10:35:32  jonathan
  33.  * Put a loop around connect in fd_connect_to_server to check if the connect
  34.  * was interrupted by a system call (usually a timer).  Retries if errno is
  35.  * EINTR.
  36.  * 
  37.  * Revision 1.19  92/02/16  12:38:22  jonathan
  38.  * Changed bzero's to memset's.
  39.  * 
  40.  * Revision 1.18  92/02/16  12:34:11  jonathan
  41.  * Removed code refering to NOINETNTOA, since we should use inet_ntoa.
  42.  * 
  43.  * Revision 1.17  92/02/12  13:48:21  jonathan
  44.  * Added "$Log" so RCS will put the log message in the header
  45.  * 
  46.  * 
  47. */
  48.  
  49. /*
  50.    Added code in fd_accept_client_connection to print source Inet address to
  51.    stderr. 
  52.    - Jonny G Fri Apr 12 1991
  53.  
  54. */
  55.  
  56. #define sockets_c
  57.  
  58. #include "sockets.h"
  59.  
  60. #ifdef NOTCPIP /* we don't have TCPIP */
  61.  
  62. void open_server (port,socket,size) long port; long* socket; long size; {}
  63. void accept_client_connection (socket,file) long socket; FILE** file; {}
  64. void close_client_connection (file) FILE* file; {}
  65. void close_server (socket) long socket; {}
  66. FILE *connect_to_server (host_name,port) char* host_name; long port; 
  67.                                   {return(NULL);}
  68. void close_connection_to_server (file) FILE* file; {}
  69.  
  70. #else /* there is TCPIP */
  71.  
  72. #include <errno.h>
  73. #include <string.h>
  74. #include "panic.h"
  75.  
  76. #if (defined(ultrix) || defined(BSD) || defined(Mach))
  77. extern int errno;
  78. #endif /* ultrix BSD or Mach */
  79.  
  80. extern char *sys_errlist[];
  81.  
  82. #ifdef WIN32
  83. char *bcopy(char*,char*,long);
  84. #endif
  85.  
  86. /* XXX
  87. still need:
  88.  non-blocking modes
  89.  special send/recieve functions? (there are now some in ui.c)
  90.  asynchronous calls?
  91. */
  92.  
  93. /* define the number of queued connections allowable on each port */
  94. #define QUEUE_SIZE 3
  95.  
  96. #ifndef WIN32
  97.  
  98. /*---------------------------------------------------------------------------*/
  99. /* Server functions                                                          */
  100. /*---------------------------------------------------------------------------*/
  101.  
  102. static boolean clr_socket _AP((struct sockaddr_in *address, long portnumber,
  103.                         long* sock));
  104.  
  105. static boolean clr_socket(address, portnumber, sock)
  106.      struct sockaddr_in *address;
  107.      long portnumber;
  108.      long *sock;
  109. {
  110.   if (errno == EADDRINUSE) {
  111.     /* Try connecting to it */
  112.     if (connect(*sock, (struct sockaddr*)address, sizeof (struct sockaddr_in)) == 0) {
  113.       close(*sock);
  114.       waislog(WLOG_HIGH, WLOG_ERROR,
  115.               "Cannot bind port %ld: (Address already in use).",
  116.               portnumber);
  117.       waislog(WLOG_HIGH, WLOG_ERROR, "waisserver is already running on this system");
  118.       panic("Exiting");
  119.     } else {
  120.       /* Connection failed; probably socket in FIN_WAIT */
  121.       int one = 1;
  122.  
  123.       (void) close(*sock);
  124.       if ((*sock = socket(AF_INET, SOCK_STREAM, 0)) < 0)
  125.         panic("Open socket failed in trying to clear the port.");
  126.       /*printf("Error binding port %d: (address already in use).\n\
  127. Attempting to clear stale socket...", portnumber);*/
  128.       if ( setsockopt(*sock, SOL_SOCKET, SO_REUSEADDR, 
  129.                       (char*)&one, sizeof (one)) < 0) {
  130.         /*printf("Warning: Setsockopt SO_REUSEADDR failed.");*/
  131.       }
  132.       address->sin_family = AF_INET;
  133.       address->sin_addr.s_addr = INADDR_ANY;
  134.  
  135.       address->sin_port = (unsigned short int)htons(portnumber);
  136.  
  137. /*      if (bind(*sock,( SOCKADDR*) address, sizeof(SOCKADDR_IN)) == 0) { */
  138.       if (bind(*sock,(struct sockaddr*) address, sizeof(*address)) == 0) {
  139.         /*printf("Successfully cleared stale EADDRINUSE error");*/
  140.       }
  141.     }
  142.   }
  143.   return(true);
  144. }
  145.  
  146.  
  147. void
  148. open_server(port,fd,size)
  149. long port;
  150. long* fd;
  151. long size;
  152. { struct sockaddr_in address;
  153.  
  154.   memset(&address, 0, sizeof(address));
  155.  
  156.   /* open the fd */
  157.   if ((*fd = socket(AF_INET,SOCK_STREAM,0)) < 0){
  158.     panic("can't get file descriptor for socket: %s", sys_errlist[errno]);
  159.   }
  160.  
  161.   address.sin_family = AF_INET;
  162.   address.sin_addr.s_addr = htonl(INADDR_ANY);
  163.   address.sin_port = (unsigned short int)htons(port);
  164.   if (bind(*fd,(struct sockaddr*)&address,sizeof(struct sockaddr)) < 0)
  165.     clr_socket(&address, port, fd);
  166.  
  167.   if (listen(*fd,QUEUE_SIZE) < 0)
  168.     panic("can't open server: %s", sys_errlist[errno]);
  169. }
  170.  
  171.  
  172.  
  173. /* This is a lower level function provided for use by the lisp version of
  174.  * this library 
  175.  * XXX should support non-blocking mode
  176.  */
  177.  
  178. #include <arpa/inet.h>
  179.  
  180. void
  181. fd_accept_client_connection(socket,fd)
  182. long socket;
  183. long* fd;
  184. { /* accept an input connection, and open a file on it */
  185.   struct sockaddr_in source;
  186.   int sourcelen;
  187. #ifdef BSD
  188.   struct in_addr {
  189.     union {
  190.       struct { u_char s_b1,s_b2,s_b3,s_b4; } S_un_b;
  191.       u_long S_addr;
  192.     } S_un;
  193.   } addr_p;
  194. #endif /* BSD */
  195.  
  196.   sourcelen = sizeof(struct sockaddr_in);
  197.  
  198.   do {
  199.     errno = 0;
  200.     *fd = accept(socket, (struct sockaddr *)&source, &sourcelen);
  201.   } while (*fd < 0 && errno == EINTR);
  202.  
  203.   if(source.sin_family == AF_INET) {
  204.     struct hostent *peer = NULL;
  205.  
  206. #ifdef __DGUX__
  207.     peer = gethostbyaddr((char *)&source.sin_addr.s_addr, 4, AF_INET);
  208. #else
  209.     peer = gethostbyaddr((struct sockaddr_in*)&source.sin_addr, 4, AF_INET);
  210. #endif
  211.  
  212.     if(peer != NULL) {
  213.       waislog(WLOG_MEDIUM, WLOG_CONNECT,
  214.               "Accepted connection from: %s [%s]",
  215.             peer ? peer->h_name : "?",
  216. #if defined(sparc) && defined(__GNUC__)
  217.               inet_ntoa(&source.sin_addr)
  218. #else
  219.               inet_ntoa(source.sin_addr)
  220. #endif                          /* sparc */
  221.               );
  222.     }
  223.     else {
  224.       waislog(WLOG_MEDIUM, WLOG_CONNECT,
  225.               "Accepted connection from: [%s]",
  226. #if defined(sparc) && defined(__GNUC__)
  227.               inet_ntoa(&source.sin_addr)
  228. #else
  229.               inet_ntoa(source.sin_addr)
  230. #endif                          /* sparc */
  231.               );
  232.     }
  233.   }
  234.   if (*fd < 0)
  235.     panic("can't accept connection");
  236. }
  237.  
  238.  
  239. /* This is the prefered C function for accepting client requests */
  240. void
  241. accept_client_connection(socket,file)
  242. long socket;
  243. FILE** file;
  244. { long fd; /* file descriptor actually used */
  245.   fd_accept_client_connection(socket,&fd);
  246.   if ((*file = fdopen(fd,"r+")) == NULL)
  247.     panic("can't accept connection");
  248. }
  249.  
  250. /* When a server wants to end the session with a client */
  251. void
  252. close_client_connection(file)
  253. FILE* file;
  254. { 
  255.   fclose(file);
  256. }
  257.  
  258. /* when exiting the top level server process (not the forked
  259.    server processes that come one per client).
  260.    Maybe we need to do this once per client as well.
  261. */
  262. void
  263. close_server(socket)
  264. long socket;
  265. {
  266.   close(socket);
  267. }
  268.  
  269. #endif /* !WIN32 */
  270.  
  271. /*---------------------------------------------------------------------------*/
  272. /* Client functions                                                          */
  273. /*---------------------------------------------------------------------------*/
  274.  
  275. /* This is a lower level function provided for use by the lisp version of
  276.  * this library 
  277.  * XXX should support non-blocking mode
  278.  */
  279.  
  280. #define HOSTNAME_BUFFER_SIZE 120
  281. #define MAX_RETRYS 10
  282.  
  283. boolean
  284. fd_connect_to_server(host_name,port,fd)
  285. char* host_name;
  286. long port;
  287. long* fd;
  288. {
  289.   char hostnamebuf[80];
  290.   long rc, i;
  291.   struct hostent *host;
  292.   /* struct servent *service = NULL; not used */
  293.   struct sockaddr_in name;
  294.  
  295.   memset((char *)&name, 0,sizeof (name));
  296.  
  297. #ifdef __DGUX__
  298.   name.sin_addr = inet_addr(host_name);
  299. #else
  300.   name.sin_addr.s_addr = inet_addr(host_name);
  301. #endif
  302.  
  303.   if (name.sin_addr.s_addr != -1) {
  304.     name.sin_family = AF_INET;
  305.     (void) strcpy(hostnamebuf, host_name);
  306.   }
  307.   else {
  308.     host = gethostbyname(host_name);
  309.  
  310.     if(NULL == host){
  311.       return FALSE;
  312.     }
  313.  
  314.     name.sin_family = host->h_addrtype;
  315. #ifdef h_addr
  316. #ifdef WIN32
  317.     bcopy(host->h_addr_list[0],
  318.           (char *)&name.sin_addr, host->h_length);
  319. #else
  320.     bcopy(host->h_addr_list[0],
  321.           (caddr_t)&name.sin_addr, host->h_length);
  322. #endif
  323. #endif
  324.     (void) strcpy(hostnamebuf, host->h_name);
  325.   }
  326.   host_name = hostnamebuf;
  327.  
  328. #ifdef WIN32
  329.   name.sin_port = (unsigned short int)htons((u_short)port);
  330. #else
  331.   name.sin_port = (unsigned short int)htons(port);
  332. #endif
  333.  
  334.   *fd = socket (AF_INET, SOCK_STREAM, 0);
  335.   for(i = 0; i < MAX_RETRYS; i++) {
  336.     rc = connect (*fd, (struct sockaddr *)&name, sizeof (name));
  337.     if(rc == 0) return TRUE;
  338.     else if(errno == EINTR){
  339. #ifdef WIN32
  340.       Sleep(1000);   /* WIN32's sleep has an unit in millisec */
  341. #else
  342.       sleep(1);
  343. #endif
  344.     }
  345.     else {
  346.       perror("Connect to socket did not work (1)");
  347.       return FALSE;
  348.     }
  349.   }
  350.   return FALSE;
  351. }
  352.  
  353. /* This is the prefered C function for initiating client requests */
  354. FILE *
  355. connect_to_server(host_name,port)
  356. char* host_name;
  357. long port;
  358. {
  359.   FILE* file;
  360.   long fd;
  361.   if(fd_connect_to_server(host_name,port,&fd) == FALSE) {
  362.     perror("Connect to socket did not work (2)");
  363.     return NULL;
  364.   }
  365.  
  366.   if ((file = fdopen(fd,"r+")) == NULL) {
  367.     perror("Connect to socket did not work (3)");
  368.     return NULL;
  369.   }
  370.  
  371.   return file;
  372. }
  373.  
  374. void
  375. close_connection_to_server(file)
  376. FILE* file;
  377. {
  378.   fclose(file);
  379. }
  380.  
  381. /*---------------------------------------------------------------------------*/
  382.  
  383. #endif /* there is TCPIP */
  384.  
  385. #ifndef WIN32
  386.  
  387. /* Francois and Jonathan Goldman - hostname fix */
  388. char *
  389. mygethostname(hostname, len)
  390. char *hostname;
  391. long len;
  392. {
  393.         char    name[255];
  394.         struct  hostent *h;
  395.  
  396.         gethostname(name, 254);
  397.         strcpy(hostname,name);
  398.  
  399.         h = gethostbyname(name);
  400.  
  401.         if ( (h = gethostbyname(name)) != NULL) {
  402.                 if ( (strlen(h->h_name) >= len) && ( len > 0 ) ) {
  403.                         strncpy(hostname, h->h_name,len-1);
  404.                 }
  405.                 else {
  406.                         strcpy(hostname, h->h_name);
  407.                 }
  408.         }
  409.         else {
  410.                 if ( ( strlen(name) >= len) && (len > 0 ) ) {
  411.                         strncpy(hostname, name, len-1);
  412.                 }
  413.                 else {
  414.                         strcpy(hostname, name);
  415.                 }
  416.         }
  417.  
  418.         return(hostname);
  419. }
  420.  
  421. #endif /* !WIN32 */
  422.